bluzphp / module-test

 * @license RequireJS text 2.0.13+ Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.

 * Available via the MIT or new BSD license.

 * see: http://github.com/requirejs/text for details

 */

/*jslint regexp: true */

/*global require, XMLHttpRequest, ActiveXObject,

  define, window, process, Packages,

  java, location, Components, FileUtils */

define(['module'], function (module) {

    'use strict';

    var text, fs, Cc, Ci, xpcIsWindows,

        progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],

        xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,

        bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,

        hasLocation = typeof location !== 'undefined' && location.href,

        defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''),

        defaultHostName = hasLocation && location.hostname,

        defaultPort = hasLocation && (location.port || undefined),

        buildMap = {},

        masterConfig = (module.config && module.config()) || {};

    text = {

        version: '2.0.13+',

        strip: function (content) {

            //Strips <?xml ...?> declarations so that external SVG and XML

            //documents can be added to a document without worry. Also, if the string

            //is an HTML document, only the part inside the body tag is returned.

            if (content) {

                content = content.replace(xmlRegExp, "");

                var matches = content.match(bodyRegExp);

                if (matches) {

                    content = matches[1];

                }

            } else {

                content = "";

            }

            return content;

        },

        jsEscape: function (content) {

            return content.replace(/(['\\])/g, '\\$1')

                .replace(/[\f]/g, "\\f")

                .replace(/[\b]/g, "\\b")

                .replace(/[\n]/g, "\\n")

                .replace(/[\t]/g, "\\t")

                .replace(/[\r]/g, "\\r")

                .replace(/[\u2028]/g, "\\u2028")

                .replace(/[\u2029]/g, "\\u2029");

        },

        /**

         * Parses a resource name into its component parts. Resource names

         * look like: module/name.ext!strip, where the !strip part is

         * optional.

         * @param {String} name the resource name

         * @returns {Object} with properties "moduleName", "ext" and "strip"

         * where strip is a boolean.

         */

        parseName: function (name) {

            var modName, ext, temp,

                strip = false,

                index = name.lastIndexOf("."),

                isRelative = name.indexOf('./') === 0 ||

                             name.indexOf('../') === 0;

            if (index !== -1 && (!isRelative || index > 1)) {

                modName = name.substring(0, index);

                ext = name.substring(index + 1);

            } else {

                modName = name;

            }

            temp = ext || modName;

            index = temp.indexOf("!");

            if (index !== -1) {

                //Pull off the strip arg.

                strip = temp.substring(index + 1) === "strip";

                temp = temp.substring(0, index);

                if (ext) {

                    ext = temp;

                } else {

                    modName = temp;

                }

            }

            return {

                moduleName: modName,

                strip: strip

            };

        },

        xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,

        /**

         * Is an URL on another domain. Only works for browser use, returns

         * false in non-browser environments. Only used to know if an

         * optimized .js version of a text resource should be loaded

         * instead.

         * @param {String} url

         * @returns Boolean

         */

        useXhr: function (url, protocol, hostname, port) {

            var uProtocol, uHostName, uPort,

                match = text.xdRegExp.exec(url);

            if (!match) {

                return true;

            }

            uProtocol = match[2];

            uHostName = match[3];

            uHostName = uHostName.split(':');

            uPort = uHostName[1];

            uHostName = uHostName[0];

            return (!uProtocol || uProtocol === protocol) &&

                   (!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) &&

                   ((!uPort && !uHostName) || uPort === port);

        },

        finishLoad: function (name, strip, content, onLoad) {

            content = strip ? text.strip(content) : content;

            if (masterConfig.isBuild) {

                buildMap[name] = content;

            }

            onLoad(content);

        },

        load: function (name, req, onLoad, config) {

            //Name has format: some.module.filext!strip

            //The strip part is optional.

            //if strip is present, then that means only get the string contents

            //inside a body tag in an HTML string. For XML/SVG content it means

            //removing the <?xml ...?> declarations so the content can be inserted

            //into the current doc without problems.

            // Do not bother with the work if a build and text will

            // not be inlined.

            if (config && config.isBuild && !config.inlineText) {

                onLoad();

                return;

            }

            masterConfig.isBuild = config && config.isBuild;

            var parsed = text.parseName(name),

                nonStripName = parsed.moduleName +

                    (parsed.ext ? '.' + parsed.ext : ''),

                url = req.toUrl(nonStripName),

                useXhr = (masterConfig.useXhr) ||

                         text.useXhr;

            // Do not load if it is an empty: url

            if (url.indexOf('empty:') === 0) {

                onLoad();

                return;

            }

            //Load the text. Use XHR if possible and in a browser.

            if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) {

                text.get(url, function (content) {

                    text.finishLoad(name, parsed.strip, content, onLoad);

                }, function (err) {

                    if (onLoad.error) {

                        onLoad.error(err);

                    }

                });

            } else {

                //Need to fetch the resource across domains. Assume

                //the resource has been optimized into a JS module. Fetch

                //by the module name + extension, but do not include the

                //!strip part to avoid file system issues.

                req([nonStripName], function (content) {

                    text.finishLoad(parsed.moduleName + '.' + parsed.ext,

                                    parsed.strip, content, onLoad);

                });

            }

        },

            if (buildMap.hasOwnProperty(moduleName)) {

                var content = text.jsEscape(buildMap[moduleName]);

                write.asModule(pluginName + "!" + moduleName,

                               "define(function () { return '" +

                                   content +

                               "';});\n");

            }

        },

        writeFile: function (pluginName, moduleName, req, write, config) {

            var parsed = text.parseName(moduleName),

                extPart = parsed.ext ? '.' + parsed.ext : '',

                nonStripName = parsed.moduleName + extPart,

                //Use a '.js' file name so that it indicates it is a

                //script that can be loaded across domains.

                fileName = req.toUrl(parsed.moduleName + extPart) + '.js';

            //Leverage own load() method to load plugin value, but only

            //write out values that do not have the strip argument,

            //to avoid any potential issues with ! in file names.

                //Use own write() method to construct full module value.

                //But need to create shell that translates writeFile's

                //write() to the right interface.

                var textWrite = function (contents) {

                    return write(fileName, contents);

                };

                textWrite.asModule = function (moduleName, contents) {

                    return write.asModule(moduleName, fileName, contents);

                };

                text.write(pluginName, nonStripName, textWrite, config);

            }, config);

        }

    };

    if (masterConfig.env === 'node' || (!masterConfig.env &&

            typeof process !== "undefined" &&

            process.versions &&

            !!process.versions.node &&

            !process.versions['node-webkit'] &&

            !process.versions['atom-shell'])) {

        //Using special require.nodeRequire, something added by r.js.

        fs = require.nodeRequire('fs');

        text.get = function (url, callback, errback) {

            try {

                var file = fs.readFileSync(url, 'utf8');

                //Remove BOM (Byte Mark Order) from utf8 files if it is there.

                if (file[0] === '\uFEFF') {

                    file = file.substring(1);

                }

                callback(file);

            } catch (e) {

                if (errback) {

                    errback(e);

                }

            }

        };

    } else if (masterConfig.env === 'xhr' || (!masterConfig.env &&

            text.createXhr())) {

        text.get = function (url, callback, errback, headers) {

            var xhr = text.createXhr(), header;

            xhr.open('GET', url, true);

            //Allow plugins direct access to xhr headers

            if (headers) {

                for (header in headers) {

                    if (headers.hasOwnProperty(header)) {

                        xhr.setRequestHeader(header.toLowerCase(), headers[header]);

                    }

                }

            }

            //Allow overrides specified in config

            if (masterConfig.onXhr) {

                masterConfig.onXhr(xhr, url);

            }

                var status, err;

                //Do not explicitly handle errors, those should be

                //visible via console output in the browser.

                if (xhr.readyState === 4) {

                    status = xhr.status || 0;

                    if (status > 399 && status < 600) {

                        //An http 4xx or 5xx error. Signal an error.

                        err = new Error(url + ' HTTP status: ' + status);

                        err.xhr = xhr;

                        if (errback) {

                            errback(err);

                        }

                    } else {

                        callback(xhr.responseText);

                    }

                    if (masterConfig.onXhrComplete) {

                        masterConfig.onXhrComplete(xhr, url);

                    }

                }

            };

            xhr.send(null);

        };

    } else if (masterConfig.env === 'rhino' || (!masterConfig.env &&

            typeof Packages !== 'undefined' && typeof java !== 'undefined')) {

        //Why Java, why is this so awkward?

        text.get = function (url, callback) {

            var stringBuffer, line,

                encoding = "utf-8",

                file = new java.io.File(url),

                lineSeparator = java.lang.System.getProperty("line.separator"),

                input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)),

                content = '';

            try {

                stringBuffer = new java.lang.StringBuffer();

                line = input.readLine();

                // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324

                // http://www.unicode.org/faq/utf_bom.html

                // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:

                // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058

                if (line && line.length() && line.charAt(0) === 0xfeff) {

                    // Eat the BOM, since we've already found the encoding on this file,

                    // and we plan to concatenating this buffer with others; the BOM should

                    // only appear at the top of a file.

                    line = line.substring(1);

                }

                if (line !== null) {

                    stringBuffer.append(line);

                }

                while ((line = input.readLine()) !== null) {

                    stringBuffer.append(lineSeparator);

                    stringBuffer.append(line);

                }

                //Make sure we return a JavaScript string and not a Java string.

                content = String(stringBuffer.toString()); //String

            } finally {

                input.close();

            }

            callback(content);

        };

    } else if (masterConfig.env === 'xpconnect' || (!masterConfig.env &&

            typeof Components !== 'undefined' && Components.classes &&

            Components.interfaces)) {

        //Avert your gaze!

        Cc = Components.classes;

        Ci = Components.interfaces;

        Components.utils['import']('resource://gre/modules/FileUtils.jsm');

        xpcIsWindows = ('@mozilla.org/windows-registry-key;1' in Cc);

        text.get = function (url, callback) {

            var inStream, convertStream, fileObj,

                readData = {};

            if (xpcIsWindows) {

                url = url.replace(/\//g, '\\');

            }

            fileObj = new FileUtils.File(url);

            //XPCOM, you so crazy

            try {

                inStream = Cc['@mozilla.org/network/file-input-stream;1']

                           .createInstance(Ci.nsIFileInputStream);

                inStream.init(fileObj, 1, 0, false);

                convertStream = Cc['@mozilla.org/intl/converter-input-stream;1']

                                .createInstance(Ci.nsIConverterInputStream);

                convertStream.init(inStream, "utf-8", inStream.available(),

                Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);

                convertStream.readString(inStream.available(), readData);

                convertStream.close();

                inStream.close();

                callback(readData.value);

            } catch (e) {

                throw new Error((fileObj && fileObj.path || '') + ': ' + e);

            }

        };

    }

    return text;